```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Java内存管理实战 - 技术小馆</title>
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
            background-color: #f8f9fa;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #222;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #6e8efb 0%, #a777e3 100%);
        }
        .card-hover {
            transition: all 0.3s ease;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1);
        }
        .highlight {
            background: linear-gradient(120deg, #f6d365 0%, #fda085 100%);
            background-repeat: no-repeat;
            background-size: 100% 40%;
            background-position: 0 88%;
        }
        .code-block {
            background-color: #2d2d2d;
            color: #f8f8f2;
            border-radius: 8px;
            font-family: 'Courier New', Courier, monospace;
        }
        .drop-cap:first-letter {
            float: left;
            font-size: 4.5em;
            line-height: 0.9;
            margin-right: 0.1em;
            margin-bottom: -0.1em;
            color: #6e8efb;
            font-weight: 700;
        }
        .tooltip:hover .tooltip-text {
            visibility: visible;
            opacity: 1;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 px-4 md:py-32">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold leading-tight mb-6">
                        Java内存管理实战指南
                    </h1>
                    <p class="text-xl md:text-2xl opacity-90 mb-8">
                        从OOM崩溃到性能翻倍：深度解析JVM内存机制与实战调优
                    </p>
                    <div class="flex flex-wrap gap-4">
                        <span class="bg-white bg-opacity-20 px-4 py-2 rounded-full">
                            <i class="fas fa-memory mr-2"></i>内存优化
                        </span>
                        <span class="bg-white bg-opacity-20 px-4 py-2 rounded-full">
                            <i class="fas fa-tachometer-alt mr-2"></i>性能调优
                        </span>
                        <span class="bg-white bg-opacity-20 px-4 py-2 rounded-full">
                            <i class="fas fa-bug mr-2"></i>问题排查
                        </span>
                    </div>
                </div>
                <div class="md:w-1/2 flex justify-center">
                    <div class="bg-white bg-opacity-20 p-6 rounded-2xl backdrop-blur-sm border border-white border-opacity-30">
                        <div class="text-sm mb-2 flex items-center">
                            <div class="w-3 h-3 rounded-full bg-red-500 mr-2"></div>
                            <div class="w-3 h-3 rounded-full bg-yellow-500 mr-2"></div>
                            <div class="w-3 h-3 rounded-full bg-green-500 mr-2"></div>
                            <span class="ml-2">JVM Memory Dashboard</span>
                        </div>
                        <div class="code-block p-4 mb-4">
                            <p class="text-green-400">$ java -Xms4g -Xmx4g -XX:+UseG1GC</p>
                            <p class="text-gray-400">> 初始化堆内存: 4GB</p>
                            <p class="text-gray-400">> 最大堆内存: 4GB</p>
                            <p class="text-gray-400">> 启用G1垃圾收集器</p>
                        </div>
                        <div class="flex justify-between text-xs text-white text-opacity-80 mb-2">
                            <span>Heap Usage</span>
                            <span>65% Used</span>
                        </div>
                        <div class="w-full bg-gray-200 bg-opacity-30 rounded-full h-2.5">
                            <div class="bg-blue-400 h-2.5 rounded-full" style="width: 65%"></div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Introduction -->
    <section class="py-16 px-4">
        <div class="container mx-auto max-w-4xl">
            <div class="bg-white rounded-xl shadow-lg overflow-hidden">
                <div class="p-8 md:p-10">
                    <p class="drop-cap text-lg md:text-xl leading-relaxed">
                        上周，我们的电商系统在促销高峰期突然崩溃，控制台疯狂输出OutOfMemoryError。紧急处理后，我们发现仅通过几行代码的调整和正确的JVM参数配置，系统吞吐量提升了200%，内存占用却降低了40%。
                    </p>
                    <div class="my-8">
                        <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1749715211905-0068daaf-071a-4881-8dd5-419c9ff8081c.png" alt="Java内存优化效果" class="rounded-lg shadow-md w-full h-auto">
                        <p class="text-center text-sm text-gray-500 mt-2">电商系统优化前后性能对比</p>
                    </div>
                    <p class="text-lg md:text-xl leading-relaxed mb-6">
                        Java内存管理就像一把双刃剑，用好了它能让你的应用性能翻倍，用不好则可能在最关键的时刻让你"翻车"。多年前我作为初级开发者时，曾因为一个内存泄漏问题熬夜三天；而现在，我可以在15分钟内定位并解决大多数内存问题。这种差距，正是源于对Java内存管理机制的深入理解和实战经验的积累。
                    </p>
                    <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded-r-lg">
                        <p class="text-blue-800 font-medium">
                            <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                            本文将分享这些来之不易的经验和技巧，帮助你从内存管理的"小白"成长为"专家"。
                        </p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <section class="py-12 px-4">
        <div class="container mx-auto max-w-6xl">
            <div class="grid md:grid-cols-12 gap-8">
                <!-- Navigation -->
                <div class="md:col-span-3">
                    <div class="sticky top-8">
                        <div class="bg-white rounded-xl shadow-md p-6">
                            <h3 class="font-bold text-xl mb-4 flex items-center">
                                <i class="fas fa-list-ul text-blue-500 mr-2"></i>
                                内容目录
                            </h3>
                            <ul class="space-y-3">
                                <li>
                                    <a href="#section1" class="text-blue-600 hover:text-blue-800 font-medium flex items-center">
                                        <i class="fas fa-microchip text-gray-400 mr-2 w-5 text-center"></i>
                                        认识Java内存模型
                                    </a>
                                    <ul class="ml-7 mt-1 space-y-2">
                                        <li><a href="#section1-1" class="text-gray-600 hover:text-blue-600 text-sm">堆内存与栈内存</a></li>
                                        <li><a href="#section1-2" class="text-gray-600 hover:text-blue-600 text-sm">方法区和常量池</a></li>
                                        <li><a href="#section1-3" class="text-gray-600 hover:text-blue-600 text-sm">JDK8后的元空间</a></li>
                                    </ul>
                                </li>
                                <li>
                                    <a href="#section2" class="text-blue-600 hover:text-blue-800 font-medium flex items-center">
                                        <i class="fas fa-trash-alt text-gray-400 mr-2 w-5 text-center"></i>
                                        垃圾回收机制
                                    </a>
                                    <ul class="ml-7 mt-1 space-y-2">
                                        <li><a href="#section2-1" class="text-gray-600 hover:text-blue-600 text-sm">分代回收策略</a></li>
                                        <li><a href="#section2-2" class="text-gray-600 hover:text-blue-600 text-sm">各类收集器对比</a></li>
                                        <li><a href="#section2-3" class="text-gray-600 hover:text-blue-600 text-sm">如何选择GC</a></li>
                                        <li><a href="#section2-4" class="text-gray-600 hover:text-blue-600 text-sm">G1调优实战</a></li>
                                    </ul>
                                </li>
                                <li>
                                    <a href="#section3" class="text-blue-600 hover:text-blue-800 font-medium flex items-center">
                                        <i class="fas fa-search text-gray-400 mr-2 w-5 text-center"></i>
                                        内存泄漏排查
                                    </a>
                                    <ul class="ml-7 mt-1 space-y-2">
                                        <li><a href="#section3-1" class="text-gray-600 hover:text-blue-600 text-sm">常见泄漏场景</a></li>
                                        <li><a href="#section3-2" class="text-gray-600 hover:text-blue-600 text-sm">工具使用技巧</a></li>
                                    </ul>
                                </li>
                                <li>
                                    <a href="#section4" class="text-blue-600 hover:text-blue-800 font-medium flex items-center">
                                        <i class="fas fa-sliders-h text-gray-400 mr-2 w-5 text-center"></i>
                                        JVM参数调优
                                    </a>
                                    <ul class="ml-7 mt-1 space-y-2">
                                        <li><a href="#section4-1" class="text-gray-600 hover:text-blue-600 text-sm">内存分配参数</a></li>
                                        <li><a href="#section4-2" class="text-gray-600 hover:text-blue-600 text-sm">GC日志分析</a></li>
                                        <li><a href="#section4-3" class="text-gray-600 hover:text-blue-600 text-sm">生产环境案例</a></li>
                                    </ul>
                                </li>
                                <li>
                                    <a href="#section5" class="text-blue-600 hover:text-blue-800 font-medium flex items-center">
                                        <i class="fas fa-code text-gray-400 mr-2 w-5 text-center"></i>
                                        编码优化技巧
                                    </a>
                                </li>
                                <li>
                                    <a href="#section6" class="text-blue-600 hover:text-blue-800 font-medium flex items-center">
                                        <i class="fas fa-random text-gray-400 mr-2 w-5 text-center"></i>
                                        并发内存陷阱
                                    </a>
                                </li>
                            </ul>
                        </div>

                        <div class="bg-white rounded-xl shadow-md p-6 mt-6">
                            <h3 class="font-bold text-xl mb-4 flex items-center">
                                <i class="fas fa-chart-line text-blue-500 mr-2"></i>
                                关键数据
                            </h3>
                            <div class="space-y-4">
                                <div>
                                    <div class="flex justify-between text-sm text-gray-600 mb-1">
                                        <span>吞吐量提升</span>
                                        <span>200%</span>
                                    </div>
                                    <div class="w-full bg-gray-200 rounded-full h-2">
                                        <div class="bg-green-500 h-2 rounded-full" style="width: 100%"></div>
                                    </div>
                                </div>
                                <div>
                                    <div class="flex justify-between text-sm text-gray-600 mb-1">
                                        <span>内存占用减少</span>
                                        <span>40%</span>
                                    </div>
                                    <div class="w-full bg-gray-200 rounded-full h-2">
                                        <div class="bg-blue-500 h-2 rounded-full" style="width: 40%"></div>
                                    </div>
                                </div>
                                <div>
                                    <div class="flex justify-between text-sm text-gray-600 mb-1">
                                        <span>GC停顿降低</span>
                                        <span>75%</span>
                                    </div>
                                    <div class="w-full bg-gray-200 rounded-full h-2">
                                        <div class="bg-purple-500 h-2 rounded-full" style="width: 75%"></div>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Article Content -->
                <div class="md:col-span-9">
                    <!-- Section 1 -->
                    <div id="section1" class="bg-white rounded-xl shadow-md overflow-hidden mb-8 card-hover">
                        <div class="bg-gradient-to-r from-blue-600 to-blue-800 px-6 py-4">
                            <h2 class="text-2xl font-bold text-white">
                                <i class="fas fa-microchip mr-2"></i>
                                1. 认识Java内存模型
                            </h2>
                        </div>
                        <div class="p-6 md:p-8">
                            <div id="section1-1" class="mb-10">
                                <h3 class="text-xl font-bold mb-4 text-blue-800 border-b border-blue-200 pb-2">
                                    1.1 堆内存与栈内存的区别
                                </h3>
                                <p class="mb-4">
                                    堆内存和栈内存是Java应用程序中两个最基本的内存区域，它们的用途和管理方式截然不同。栈内存主要存储局部变量和方法调用，特点是分配迅速、回收自动；而堆内存则保存所有的对象实例，是垃圾回收的主战场。
                                </p>
                                <div class="grid md:grid-cols-2 gap-6 mb-6">
                                    <div>
                                        <div class="bg-gray-50 border border-gray-200 rounded-lg p-4">
                                            <h4 class="font-bold text-blue-600 mb-2">堆内存</h4>
                                            <ul class="list-disc pl-5 space-y-1 text-sm">
                                                <li>存储对象实例</li>
                                                <li>GC主要工作区域</li>
                                                <li>可以被多个线程共享</li>
                                                <li>分配速度较慢</li>
                                            </ul>
                                        </div>
                                    </div>
                                    <div>
                                        <div class="bg-gray-50 border border-gray-200 rounded-lg p-4">
                                            <h4 class="font-bold text-blue-600 mb-2">栈内存</h4>
                                            <ul class="list-disc pl-5 space-y-1 text-sm">
                                                <li>存储局部变量和方法调用</li>
                                                <li>线程私有</li>
                                                <li>自动分配和回收</li>
                                                <li>分配速度非常快</li>
                                            </ul>
                                        </div>
                                    </div>
                                </div>
                                <p class="mb-4">
                                    在实际应用中，我们经常会看到这样的代码：
                                </p>
                                <div class="code-block p-4 mb-4 rounded-lg">
                                    <pre><code class="language-java">String str = new String("hello");</code></pre>
                                </div>
                                <p class="mb-4">
                                    这行简单的代码实际上在内存中创建了两个对象：一个在常量池中，另一个在堆上。如果频繁执行类似操作，就会造成大量重复对象，浪费宝贵的内存资源。改进方法很简单：
                                </p>
                                <div class="code-block p-4 mb-4 rounded-lg">
                                    <pre><code class="language-java">String str = "hello";</code></pre>
                                </div>
                                <div class="bg-green-50 border-l-4 border-green-500 p-4 rounded-r-lg">
                                    <p class="text-green-800">
                                        <i class="fas fa-check-circle text-green-500 mr-2"></i>
                                        在一个消息处理系统中，仅这一个小改动就减少了15%的内存占用！
                                    </p>
                                </div>
                            </div>

                            <div id="section1-2" class="mb-10">
                                <h3 class="text-xl font-bold mb-4 text-blue-800 border-b border-blue-200 pb-2">
                                    1.2 方法区和常量池如何影响性能
                                </h3>
                                <p class="mb-4">
                                    方法区存储类的元信息和静态变量，而常量池则存储字符串常量和类常量。在频繁使用字符串拼接的场景下，不恰当的实现会导致常量池膨胀。
                                </p>
                                <p class="mb-4">
                                    例如，以下代码在循环中使用"+"拼接字符串：
                                </p>
                                <div class="code-block p-4 mb-4 rounded-lg">
                                    <pre><code class="language-java">String result = "";
for (int i = 0; i < 10000; i++) {
    result += i;
}</code></pre>
                                </div>
                                <p class="mb-4">
                                    这会创建近10000个临时String对象！更高效的方式是使用StringBuilder：
                                </p>
                                <div class="code-block p-4 mb-4 rounded-lg">
                                    <pre><code class="language-java">StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String result = sb.toString();</code></pre>
                                </div>
                                <div class="bg-yellow-50 border-l-4 border-yellow-500 p-4 rounded-r-lg">
                                    <p class="text-yellow-800">
                                        <i class="fas fa-chart-bar text-yellow-500 mr-2"></i>
                                        在一个日志处理模块中，我们通过这种优化将内存使用降低了30%，CPU利用率降低了25%。
                                    </p>
                                </div>
                            </div>

                            <div id="section1-3">
                                <h3 class="text-xl font-bold mb-4 text-blue-800 border-b border-blue-200 pb-2">
                                    1.3 JDK8后的元空间革命
                                </h3>
                                <p class="mb-4">
                                    JDK8引入的元空间取代了永久代，这是Java内存管理的一次重大革命。元空间使用的是本机内存，而不是JVM堆内存，这意味着它的大小限制主要取决于系统内存。
                                </p>
                                <div class="grid md:grid-cols-2 gap-6 mb-6">
                                    <div>
                                        <div class="bg-gray-50 border border-gray-200 rounded-lg p-4">
                                            <h4 class="font-bold text-blue-600 mb-2">永久代 (JDK7及之前)</h4>
                                            <ul class="list-disc pl-5 space-y-1 text-sm">
                                                <li>位于JVM堆内存中</li>
                                                <li>大小受限(-XX:MaxPermSize)</li>
                                                <li>Full GC时回收</li>
                                                <li>容易导致OOM</li>
                                            </ul>
                                        </div>
                                    </div>
                                    <div>
                                        <div class="bg-gray-50 border border-gray-200 rounded-lg p-4">
                                            <h4 class="font-bold text-blue-600 mb-2">元空间 (JDK8+)</h4>
                                            <ul class="list-disc pl-5 space-y-1 text-sm">
                                                <li>使用本地内存</li>
                                                <li>默认无上限</li>
                                                <li>可设置上限(-XX:MaxMetaspaceSize)</li>
                                                <li>减少Full GC</li>
                                            </ul>
                                        </div>
                                    </div>
                                </div>
                                <p class="mb-4">
                                    在一个微服务项目中，我们遇到过由于大量动态加载类导致的"Metaspace OOM"问题。通过设置：
                                </p>
                                <div class="code-block p-4 mb-4 rounded-lg">
                                    <pre><code class="language-plaintext">-XX:MaxMetaspaceSize=256m</code></pre>
                                </div>
                                <p>
                                    我们不仅解决了OOM问题，还能提前发现类加载异常，避免系统在高峰期崩溃。
                                </p>
                            </div>
                        </div>
                    </div>

                    <!-- Section 2 -->
                    <div id="section2" class="bg-white rounded-xl shadow-md overflow-hidden mb-8 card-hover">
                        <div class="bg-gradient-to-r from-purple-600 to-purple-800 px-6 py-4">
                            <h2 class="text-2xl font-bold text-white">
                                <i class="fas fa-trash-alt mr-2"></i>
                                2. 垃圾回收机制
                            </h2>
                        </div>
                        <div class="p-6 md:p-8">
                            <div id="section2-1" class="mb-10">
                                <h3 class="text-xl font-bold mb-4 text-purple-800 border-b border-purple-200 pb-2">
                                    2.1 分代回收策略解析
                                </h3>
                                <p class="mb-4">
                                    Java的GC基于"弱分代假设"：大多数对象生命周期很短，少数对象会长期存活。因此，JVM将堆分为年轻代和老年代，分别采用不同的回收策略。
                                </p>
                                <div class="bg-gray-50 rounded-lg p-6 mb-6">
                                    <div class="mermaid">
                                        graph LR
                                            A[Java堆] --> B[年轻代]
                                            A --> C[老年代]
                                            B --> D[Eden区]
                                            B --> E[Survivor区 S0]
                                            B --> F[Survivor区 S1]
                                    </div>
                                </div>
                                <p class="mb-4">
                                    年轻代使用复制算法，效率高但耗内存；老年代使用标记-清除或标记-整理算法，节省空间但速度较慢。
                                </p>
                                <p class="mb-4">
                                    在实际优化中，我们发现一个有趣的现象：将对象预分配到老年代反而提高了性能。在一个缓存系统中，我们使用：
                                </p>
                                <div class="code-block p-4 mb-4 rounded-lg">
                                    <pre><code class="language-plaintext">-XX:PretenureSizeThreshold=3M</code></pre>
                                </div>
                                <p>
                                    使大对象直接进入老年代，避免了频繁的Minor GC，系统吞吐量提升了35%。
                                </p>
                            </div>

                            <div id="section2-2" class="mb-10">
                                <h3 class="text-xl font-bold mb-4 text-purple-800 border-b border-purple-200 pb-2">
                                    2.2 各类垃圾收集器对比
                                </h3>
                                <p class="mb-6">
                                    从Serial、Parallel到CMS和G1，每种垃圾收集器都有其适用场景：
                                </p>
                                <div class="overflow-x-auto mb-6">
                                    <table class="min-w-full bg-white rounded-lg overflow-hidden">
                                        <thead class="bg-gray-100">
                                            <tr>
                                                <th class="py-3 px-4 text-left font-semibold text-gray-700">收集器</th>
                                                <th class="py-3 px-4 text-left font-semibold text-gray-700">算法</th>
                                                <th class="py-3 px-4 text-left font-semibold text-gray-700">线程</th>
                                                <th class="py-3 px-4 text-left font-semibold text-gray-700">适用场景</th>
                                            </tr>
                                        </thead>
                                        <tbody class="divide-y divide-gray-200">
                                            <tr>
                                                <td class="py-3 px-4">Serial</td>
                                                <td class="py-3 px-4">标记-整理</td>
                                                <td class="py-3 px-4">单线程</td>
                                                <td class="py-3 px-4">小内存环境</td>
                                            </tr>
                                            <tr class="bg-gray-50">
                                                <td class="py-3 px-4">Parallel</td>
                                                <td class="py-3 px-4">标记-整理</td>
                                                <td class="py-3 px-4">多线程</td>
                                                <td class="py-3 px-4">注重吞吐量</td>
                                            </tr>
                                            <tr>
                                                <td class="py-3 px-4">CMS</td>
                                                <td class="py-3 px-4">标记-清除</td>
                                                <td class="py-3 px-4">并发</td>
                                                <td class="py-3 px-4">注重低停顿</td>
                                            </tr>
                                            <tr class="bg-gray-50">
                                                <td class="py-3 px-4">G1</td>
                                                <td class="py-3 px-4">分区收集</td>
                                                <td class="py-3 px-4">并发</td>
                                                <td class="py-3 px-4">兼顾吞吐和停顿</td>
                                            </tr>
                                        </tbody>
                                    </table>
                                </div>
                                <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded-r-lg">
                                    <p class="text-blue-800">
                                        <i class="fas fa-star text-blue-500 mr-2"></i>
                                        在一个交易系统中，我们从Parallel切换到G1收集器后，系统的99.9%延迟从600ms降低到了150ms，这对用户体验是质的提升。
                                    </p>
                                </div>
                            </div>

                            <div id="section2-3" class="mb-10">
                                <h3 class="text-xl font-bold mb-4 text-purple-800 border-b border-purple-200 pb-2">
                                    2.3 如何选择最适合你应用的GC
                                </h3>
                                <p class="mb-4">
                                    选择GC收集器要考虑三个关键指标：吞吐量、停顿时间和内存占用。
                                </p>
                                <div class="grid md:grid-cols-3 gap-6 mb-6">
                                    <div class="bg-gray-50 border border-gray-200 rounded-lg p-4">
                                        <h4 class="font-bold text-blue-600 mb-2">实时交易系统</h4>
                                        <p class="text-sm mb-2">优先考虑停顿时间</p>
                                        <div class="bg-blue-100 text-blue-800 text-xs px-2 py-1 rounded inline-block">CMS</div>
                                        <div class="bg-blue-100 text-blue-800 text-xs px-2 py-1 rounded inline-block ml-1">G1</div>
                                    </div>
                                    <div class="bg-gray-50 border border-gray-200 rounded-lg p-4">
                                        <h4 class="font-bold text-blue-600 mb-2">后台批处理系统</h4>
                                        <p class="text-sm mb-2">优先考虑吞吐量</p>
                                        <div class="bg-purple-100 text-purple-800 text-xs px-2 py-1 rounded inline-block">Parallel</div>
                                    </div>
                                    <div class="bg-gray-50 border border-gray-200 rounded-lg p-4">
                                        <h4 class="font-bold text-blue-600 mb-2">混合型应用</h4>
                                        <p class="text-sm mb-2">根据场景切换</p>
                                        <div class="bg-green-100 text-green-800 text-xs px-2 py-1 rounded inline-block">G1</div>
                                        <div class="bg-green-100 text-green-800 text-xs px-2 py-1 rounded inline-block ml-1">定制方案</div>
                                    </div>
                                </div>
                                <p>
                                    我曾经为一个混合型应用（既有API服务，又有批处理任务）设计了两套JVM参数，分别针对不同场景切换，最终使系统既能满足API响应时间要求，又能高效处理批量数据。
                                </p>
                            </div>

                            <div id="section2-4">
                                <h3 class="text-xl font-bold mb-4 text-purple-800 border-b border-purple-200 pb-2">
                                    2.4 G1收集器调优实战
                                </h3>
                                <p class="mb-4">
                                    G1收集器是当前Java应用的主流选择，它的关键调优参数包括：
                                </p>
                                <div class="code-block p-4 mb-6 rounded-lg">
                                    <pre><code class="language-plaintext">-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:InitiatingHeapOccupancyPercent=45</code></pre>
                                </div>
                                <div class="bg-gray-50 rounded-lg p-6 mb-6">
                                    <div class="mermaid">
                                        flowchart LR
                                            Start[G1调优步骤] --> A[设置堆大小 -Xms -Xmx]
                                            A --> B[设置最大停顿时间 -XX:MaxGCPauseMillis]
                                            B --> C[设置并发周期触发阈值 -XX:InitiatingHeapOccupancyPercent]
                                            C --> D[可选: 设置Region大小 -XX:G1HeapRegionSize]
                                            D --> E[可选: 设置并行GC线程数 -XX:ParallelGCThreads]
                                    </div>
                                </div>
                                <div class="bg-orange-50 border-l-4 border-orange-500 p-4 rounded-r-lg">
                                    <p class="text-orange-800">
                                        <i class="fas fa-bolt text-orange-500 mr-2"></i>
                                        在一次双11大促中，我们通过调整这些参数，使系统在访问量增加5倍的情况下，仍然保持了200ms以内的GC停顿时间，成功避免了用户感知的卡顿。
                                    </p>
                                </div>
                            </div>
                        </div>
                    </div>

                    <!-- More Sections... -->
                    <div class="text-center py-8">
                        <h3 class="text-xl font-bold text-gray-700 mb-4">文章内容继续...</h3>
                        <p class="text-gray-600">后续章节包含更多实战经验和高级技巧</p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```